/**
 * 
 */
package com.yidu.erp.service.exam;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.yidu.erp.dao.BeyondDepMapper;
import com.yidu.erp.dao.BeyondExamMapper;
import com.yidu.erp.dao.BeyondFdproformMapper;
import com.yidu.erp.dao.BeyondFinancialExpenditureMapper;
import com.yidu.erp.dao.BeyondFinancialIncomeMapper;
import com.yidu.erp.dao.BeyondInventoryMapper;
import com.yidu.erp.dao.BeyondMoneyMapper;
import com.yidu.erp.dao.BeyondPlanmxMapper;
import com.yidu.erp.dao.BeyondProcurelistMapper;
import com.yidu.erp.dao.BeyondProdesignMapper;
import com.yidu.erp.dao.BeyondSalplanMapper;
import com.yidu.erp.model.BeyondDep;
import com.yidu.erp.model.BeyondExam;
import com.yidu.erp.model.BeyondFdproform;
import com.yidu.erp.model.BeyondFinancialExpenditure;
import com.yidu.erp.model.BeyondFinancialIncome;
import com.yidu.erp.model.BeyondInventory;
import com.yidu.erp.model.BeyondProcurelist;
import com.yidu.erp.model.BeyondProdesign;
import com.yidu.erp.model.BeyondSalplan;
import com.yidu.erp.service.stock.StockService;

/**
 * 审核Service实现类
 * @author zengren
 * @date 2017年11月27日
 * @version 1.0
 */
@Service
public class ExamServiceImpl implements ExamService{
	
	/**
	 * 审核表Mapper
	 */
	@Resource
	private BeyondExamMapper beyondExamMapper;
	
	/**
	 * 总店销售Mapper
	 */
	@Resource
	private BeyondSalplanMapper beyondSalplanMapper;
	
	/**
	 * 总店销售明细Mapper
	 */
	@Resource
	private BeyondPlanmxMapper beyondPlanmxMapper;

	/**
	 * 分店采购Mapper
	 */
	@Resource
	private BeyondFdproformMapper beyondFdproformMapper;

	/**
	 * 总店采购Mapper
	 */
	@Resource
	private BeyondProcurelistMapper beyondProcurelistMapper;
	
	/**
	 * 财务表Mapper
	 */
	@Resource
	private BeyondMoneyMapper beyondMoneyMapper;
	
	/**
	 * 财务收入Mapper
	 */
	@Resource
	private BeyondFinancialIncomeMapper beyondFinancialIncomeMapper;
	
	/**
	 * 财务收入Mapper
	 */
	@Resource
	private BeyondFinancialExpenditureMapper beyondFinancialExpenditureMapper;
	
	/**
	 * 库存Service
	 */
	@Resource
	private StockService stockService;
	
	/**
	 * 生产计划Mapper
	 */
	@Resource
	private BeyondProdesignMapper beyondProdesignMapper;
	
	/**
	 * 配料Mapper
	 */
	@Resource
	private BeyondDepMapper beyondDepMapper;
	
	/**
	 * 库存Mapper
	 */
	@Resource
	private BeyondInventoryMapper beyondInventoryMapper;

	@Override
	public Map<String, Object> showZPurchase(Map<String, Object> paramMap) {
		//创建一个map对象。
		Map<String, Object> map = new HashMap<String, Object>();
		//将查询出来的集合放到map中
		map.put("data", beyondExamMapper.showZPurchase(paramMap));
		//将总行数放入到map中
		map.put("count", beyondExamMapper.showZPurchaseCount(paramMap));
		//设置编码
		map.put("code", 0);
		//设置消息
		map.put("msg", 0);
		return map;
	}

	@Override
	public List<Map<String, Object>> findCaiGById(Map<String, Object> paramMap) {
		// TODO Auto-generated method stub
		return beyondExamMapper.findCaiGById(paramMap);
	}

	@Override
	public Map<String, Object> showZMarket(Map<String, Object> paramMap) {
		//创建一个map对象。
		Map<String, Object> map = new HashMap<String, Object>();
		//将查询出来的集合放到map中
		map.put("data", beyondExamMapper.showZMarket(paramMap));
		//将总行数放入到map中
		map.put("count", beyondExamMapper.showZMarketCount(paramMap));
		//设置消息
		map.put("msg", 0);
		//设置编码
		map.put("code", 0);
		return map;
	}

	@Override
	public Map<String, Object> showFPurchase(Map<String, Object> paramMap) {
		//创建一个map对象。
		Map<String, Object> map = new HashMap<String, Object>();
		//将查询出来的集合放到data中
		map.put("data", beyondExamMapper.showFPurchase(paramMap));
		//将总行数放入到count中
		map.put("count", beyondExamMapper.showFPurchaseCount(paramMap));
		//设置编码
		map.put("code", 0);
		//设置消息
		map.put("msg", 0);
		return map;
	}

	@Override
	public List<Map<String, Object>> findCaiGByIdFd(Map<String, Object> paramMap) {
		// TODO Auto-generated method stub
		return beyondExamMapper.findCaiGByIdFd(paramMap);
	}

	@Override
	public int insertInto(Map<String, Object> map) {
		//创建审核对象
		BeyondExam exam = new BeyondExam();
		//审核条目
		exam.setExamEntry(map.get("examEntry").toString());
		//审核状态
		exam.setExamIsvo(map.get("state").toString());
		//备注
		exam.setExamRemark(map.get("textarea").toString());
		//审核人
		exam.setExamOpinoin(map.get("staffName").toString());
		//审核人id
		exam.setExamOpinoinId(map.get("staffId").toString());
		return beyondExamMapper.insertSelective(exam);
	}

	@Override
	public int fAuditFinance(Map<String, Object> map) {
		//调用增加审核记录方法
		int rows = this.insertInto(map);
		//将map中的属性封装到对象
		BeyondFdproform form = new BeyondFdproform();
		//得到审核条目
		form.setFdproId(map.get("examEntry").toString());
		//设置状态
		form.setFdproIvso(map.get("state").toString());
		//调用修改分店采购的状态
		rows = beyondFdproformMapper.updateBy(form);
		return rows;
	}

	@Override
	public int fAuditBoss(Map<String, Object> paramMap) {
		//创建分店采购对象
		BeyondFdproform form = new BeyondFdproform();
		//得到map中的分店采购id
		form.setFdproId(paramMap.get("examEntry").toString());
		//设置状态
		form.setFdproIvso(paramMap.get("state").toString());		
		int rows = beyondFdproformMapper.updateBy(form);
		//调用增加审核记录方法
		rows += this.insertInto(paramMap);
		if("2".equals(paramMap.get("state").toString())){
			//创建map对象
			Map<String, Object> map = new HashMap<String, Object>();
			//将分店采购单id放入map总
			map.put("fdproId", paramMap.get("examEntry"));
			//掉用总店销售的copy分店数据方法
			rows += beyondSalplanMapper.copyFdProDate(map);
		}
		return rows;
	}

	@Override
	public int zAuditFinance(Map<String, Object> paramMap) {
		int rows = 0;
		if("1".equals(paramMap.get("skType").toString())){//审核总店销售
			//创建总店销售对象
			BeyondSalplan salplan = new BeyondSalplan();
			//设置主键
			salplan.setPlanId(paramMap.get("examEntry").toString());
			//设置状态
			salplan.setExamState(paramMap.get("state").toString());
			if("3".equals(paramMap.get("state").toString())){//如果状态是打回，修改分店采购状态为打回。
				//创建分店采购对象
				BeyondFdproform form = new BeyondFdproform();
				//设置分店采购id
				form.setFdproId(paramMap.get("fdProId").toString());
				//设置状态
				form.setFdproIvso(paramMap.get("state").toString());
				//修改分店采购
				rows += beyondFdproformMapper.updateBy(form);
			}
			//修改总店销售
			rows += beyondSalplanMapper.updateByPrimaryKeySelective(salplan);
		}else if("2".equals(paramMap.get("skType").toString())){//总店采购审核
			//创建采购对象
			BeyondProcurelist pro = new BeyondProcurelist();
			//设置id
			pro.setProlistId(paramMap.get("examEntry").toString());
			//设置状态
			pro.setProlistState(paramMap.get("state").toString());
			//财务审核。修改状态。
			rows += beyondProcurelistMapper.updateByPrimaryKeySelective(pro);
		}else if("3".equals(paramMap.get("skType").toString())){//生产审核
			//创建生产对象
			BeyondProdesign pro = new BeyondProdesign();
			//设置id
			pro.setDesignId(paramMap.get("examEntry").toString());
			//设置状态
			pro.setDesignIsvo(paramMap.get("state").toString());
			//修改生产计划的状态
			beyondProdesignMapper.updateByPrimaryKeySelective(pro);
		}
		rows += this.insertInto(paramMap);//审核完成添加审核记录。
		return rows;
	}

	@Override
	public int zAuditBoss(Map<String, Object> paramMap) {
		// TODO Auto-generated method stub
		int rows = 0;
		if("1".equals(paramMap.get("skType").toString())){//1：审核总店销售
			//如果状态是打回，修改分店采购状态为打回。
			if("3".equals(paramMap.get("state").toString())){
				
			}else{//通过就更改财务，库存。
				//创建map对象
				Map<String, Object> map = new HashMap<String, Object>();
				//设置销售id为map参数中的id
				map.put("planId", paramMap.get("examEntry"));
				//将销售单的详情查询出来
				List<Map<String, Object>> list = this.findCaiGByIdZd(map);
				//定义总金额
				BigDecimal bigDecimal = new BigDecimal("0");
				//修改库存之前判断库存是否充足
				for(Map<String, Object> m : list){//循环出销售详情map对象
					//创建库存对象。
					BeyondInventory beyondInventory = new BeyondInventory();
					//设置分店id为1
					beyondInventory.setAnnexId("1");
					//设置库存物品编码为map对象中的药品id
					beyondInventory.setInventoryCode(m.get("WARE_ID").toString());
					//定义采购数为map对象中的销售明细数
					int cNum = Integer.valueOf(m.get("PLANMX_NUM").toString());
					//查询出当前库存数
					Integer kNum = beyondInventoryMapper.findInventory(beyondInventory);
					if(kNum==null || cNum>kNum){//当采购数大于库存数时
						return -1;//返回一个-1的状态。
					}
				}
				
				for(Map<String, Object> m : list){//循环取出总店销售单明细对象
					//创建库存对象。
					BeyondInventory beyondInventory = new BeyondInventory();
					//设置分店id为1
					beyondInventory.setAnnexId("1");
					//从集合中遍历出来的map对象中的到药品ID
					beyondInventory.setInventoryCode(m.get("WARE_ID").toString());
					//从集合中遍历出来的map对象中的到需求数
					beyondInventory.setInventoryNum(Integer.valueOf(m.get("PLANMX_NUM").toString()));
					//减少总店库存
					stockService.addOrMinus(beyondInventory, "-");
					//修改库存对象的分店id为map参数中的分店id
					beyondInventory.setAnnexId(paramMap.get("annexId").toString());
					//增加分店库存
					stockService.addOrMinus(beyondInventory, "+");
					//总金额累加，得到销售单明细的价格
					bigDecimal = bigDecimal.add(new BigDecimal(m.get("PLANMX_MONEY").toString()));
					rows ++;
				} 
				//新建财务收入对象。
				BeyondFinancialIncome inco = new BeyondFinancialIncome();
				//设置id为UUID
				inco.setInId(UUID.randomUUID().toString());
				//设置分店id为总店的id
				inco.setAnnexId("1");
				//将前面累加起来的价格封装对象中
				inco.setInMoney(bigDecimal);
				//添加总店财务收入记录
				rows += beyondFinancialIncomeMapper.insertSelective(inco);
				//新建财务支出对象
				BeyondFinancialExpenditure expend = new BeyondFinancialExpenditure();
				//设置id为UUID
				expend.setOutId(UUID.randomUUID().toString());
				//修改库存对象的分店id为map参数中的分店id
				expend.setAnnexId(paramMap.get("annexId").toString());
				//将前面累加起来的价格封装对象中
				expend.setOutMoney(bigDecimal);
				//添加分店财务支出记录
				rows += beyondFinancialExpenditureMapper.insertSelective(expend);
				//创建map对象，用来修改总财务
				Map<String, Object> moneyMap = new HashMap<String, Object>();
				//设置分店id为总店
				moneyMap.put("annexId", "1");
				//设置运算符为加号
				moneyMap.put("oper", "+");
				//设置金额为之前累加的总金额
				moneyMap.put("money", bigDecimal);
				//修改总店财务
				rows += beyondMoneyMapper.addOrSub(moneyMap);
				//设置分店id为map参数中的分店id
				moneyMap.put("annexId", paramMap.get("annexId"));
				//设置运算符为减号
				moneyMap.put("oper", "-");
				//设置金额为之前累加的总金额
				moneyMap.put("money", bigDecimal);
				//修改分店财务
				rows += beyondMoneyMapper.addOrSub(moneyMap);
			}
			//创建分店采购的对象
			BeyondFdproform form = new BeyondFdproform();
			//设置id为map参数中的分店采购id
			form.setFdproId(paramMap.get("fdProId").toString());
			//设置状态为map参数中的状态
			form.setFdproIvso(paramMap.get("state").toString());
			//掉用别人的修改方法
			rows += beyondFdproformMapper.updateBy(form);
			//创建总店销售对象
			BeyondSalplan salplan = new BeyondSalplan();
			//设置主键
			salplan.setPlanId(paramMap.get("examEntry").toString());
			//设置状态
			salplan.setExamState(paramMap.get("state").toString());
			//修改总店销售
			rows += beyondSalplanMapper.updateByPrimaryKeySelective(salplan);
		}else if("2".equals(paramMap.get("skType").toString())){//2：总店采购审核
			//创建总店采购对象
			BeyondProcurelist pro = new BeyondProcurelist();
			//将id设值为map参数中的id
			pro.setProlistId(paramMap.get("examEntry").toString());
			//将状态设置为map参数中的状态
			pro.setProlistState(paramMap.get("state").toString());
			//调用别人的修改总店采购的状态
			beyondProcurelistMapper.updateByPrimaryKeySelective(pro);
			if("3".equals(paramMap.get("state").toString())){//审核不通过就没有然后了
				
			}else{
				//将map参数中的id给map中的采购单id
				paramMap.put("prolistId", paramMap.get("examEntry"));
				//调用根据采购单id查询详情（总店采购）方法
				List<Map<String, Object>> list = beyondExamMapper.findCaiGById(paramMap);
				//定义总金额。
				BigDecimal bigDecimal = new BigDecimal("0");
				if("1".equals(paramMap.get("proType").toString())){//1：商品采购
					for(Map<String, Object> m : list){//循环出明细对象集合中的map对象
						//创建库存对象。
						BeyondInventory beyondInventory = new BeyondInventory();
						//设置分店id为1
						beyondInventory.setAnnexId("1");
						//从map对象中得到药品id
						beyondInventory.setInventoryCode(m.get("WARE_ID").toString());
						//从map对象中得到药品明细数量
						beyondInventory.setInventoryNum(Integer.valueOf(m.get("PROLISTMX_COUNT").toString()));
						//增加总店库存
						stockService.addOrMinus(beyondInventory, "+");
						//将明细的金额累加
						bigDecimal = bigDecimal.add(new BigDecimal(m.get("PROLISTMX_MONEY").toString()));
						rows ++;
					}
				}else{//2：配料采购
					for(Map<String, Object> m : list){//循环出明细对象集合中的map对象
						//创建库存对象。
						BeyondInventory beyondInventory = new BeyondInventory();
						//设置分店id为1
						beyondInventory.setAnnexId("1");
						//从map对象中得到配料id
						beyondInventory.setInventoryCode(m.get("DOS_ID").toString());
						//从map对象中得到配料明细数量
						beyondInventory.setInventoryNum(Integer.valueOf(m.get("DOSING_PROLISTMX_COUNT").toString()));//从map中取出配料明细数量
						//增加总店库存
						stockService.addOrMinus(beyondInventory, "+");
						//将明细的金额累加
						bigDecimal = bigDecimal.add(new BigDecimal(m.get("DOSING_PROLISTMX_MONEY").toString()));
						rows ++;
					}
				}
				
				//新建财务支出对象。
				BeyondFinancialExpenditure expend = new BeyondFinancialExpenditure();
				//设置id为UUID
				expend.setOutId(UUID.randomUUID().toString());
				//设置分店id为1
				expend.setAnnexId("1");
				//将累加的总金额
				expend.setOutMoney(bigDecimal);
				//添加分店财务支出记录
				rows += beyondFinancialExpenditureMapper.insertSelective(expend);
				//创建财务map
				Map<String, Object> moneyMap = new HashMap<String, Object>();
				//设置分店id为1
				moneyMap.put("anndxId", "1");
				//设置运算符为减号，减少总店财务
				moneyMap.put("oper", "-");
				//设置金额为之前累加的总金额
				moneyMap.put("money", bigDecimal);
				//修改总店财务
				rows += beyondMoneyMapper.addOrSub(moneyMap);
			}
			//创建总店销售对象
			BeyondSalplan salplan = new BeyondSalplan();
			//设置id为map参数中的id
			salplan.setPlanId(paramMap.get("examEntry").toString());
			//设置状态为map参数中的状态
			salplan.setExamState(paramMap.get("state").toString());
			//调用修改总店销售方法
			rows += beyondSalplanMapper.updateByPrimaryKeySelective(salplan);
		}else if("3".equals(paramMap.get("skType").toString())){//3：生产计划审核
			
			if("3".equals(paramMap.get("state").toString())){//审核不通过
				
			}else{
				//通过map参数中的id查询到生产明细集合
				List<Map<String, Object>> desList = this.findSenC(paramMap.get("examEntry").toString());
				//循环出集合中的map对象
				for(Map<String, Object> desMap : desList){
					//调用别人的根据药品编号查询药品配料方的方法，通过map对象中的药品id查询出药品配料配方的集合
					List<BeyondDep> list = beyondDepMapper.findByWareId(desMap.get("WARE_ID").toString());
					//定义药品的需求配料数
					BigDecimal totalNum = new BigDecimal("0");
					//循环出配方对象
					for(BeyondDep dep : list){
						//设置药品的需求配料数为配方需求数乘以map对象中的生产数
						totalNum = dep.getDosCount().multiply(new BigDecimal(desMap.get("DESMX_COUNT").toString()));
						//创建一个库存对象
						BeyondInventory inventory = new BeyondInventory();
						//设置分店id为1
						inventory.setAnnexId("1");
						//设置物品编码为配方中的配料主键
						inventory.setInventoryCode(dep.getDosId());
						//定义需要配料数为
						int cNum = totalNum.intValue();
						//掉用根据存入的物品编号和分店编号进行查询方法查询出配料的库存
						int kNum = beyondInventoryMapper.findInventory(inventory);
						if(cNum>kNum){//当库存不足时
							return -1;//返回一个-1的状态。
						}
					}
				}
				
				//循环出集合中的map对象（库存充足）
				for(Map<String, Object> desMap : desList){
					//调用别人的根据药品编号查询药品配料方的方法，通过map对象中的药品id查询出药品配料配方的集合
					List<BeyondDep> list = beyondDepMapper.findByWareId(desMap.get("WARE_ID").toString());
					//定义药品的需求配料数
					BigDecimal totalNum = new BigDecimal("0");
					//循环出配方对象
					for(BeyondDep dep : list){
						//设置药品的需求配料数为配方需求数乘以map对象中的生产数
						totalNum = dep.getDosCount().multiply(new BigDecimal(desMap.get("DESMX_COUNT").toString()));
						//创建一个库存对象
						BeyondInventory inventory = new BeyondInventory();
						//设置分店id为1
						inventory.setAnnexId("1");
						//设置物品编码为配方中的配料主键
						inventory.setInventoryCode(dep.getDosId());
						//定义需要配料数为
						inventory.setInventoryNum(totalNum.intValue());
						//审核完成，减少配料库存。
						stockService.addOrMinus(inventory, "-");
					}
					//定义库存对象
					BeyondInventory troy = new BeyondInventory();
					//设置分店id为1
					troy.setAnnexId("1");
					//设置数量为map对象中的明细数量
					troy.setInventoryNum(Integer.valueOf(desMap.get("DESMX_COUNT").toString()));
					//id为map对象中的药品对象
					troy.setInventoryCode(desMap.get("WARE_ID").toString());
					//增加总店商品库存
					stockService.addOrMinus(troy, "+");
				}
			}
			//创建生产计划对象
			BeyondProdesign pro = new BeyondProdesign();
			//设置id为map参数中的id
			pro.setDesignId(paramMap.get("examEntry").toString());
			//设置状态为map参数中的状态
			pro.setDesignIsvo(paramMap.get("state").toString());
			//调用修改生产计划的方法修改状态
			beyondProdesignMapper.updateByPrimaryKeySelective(pro);
		}
		rows += this.insertInto(paramMap);//审核完成添加审核记录。
		return rows;
	}

	@Override
	public List<Map<String, Object>> findCaiGByIdZd(Map<String, Object> paramMap) {
		// TODO Auto-generated method stub
		return beyondExamMapper.findCaiGByIdZd(paramMap);
	}

	@Override
	public List<Map<String, Object>> queryExamOld(String entryId) {
		// TODO Auto-generated method stub
		return beyondExamMapper.queryExamOld(entryId);
	}

	@Override
	public Map<String, Object> showZProduce(Map<String, Object> paramMap) {
		// TODO Auto-generated method stub
		//创建map对象
		Map<String, Object> map = new HashMap<String, Object>();
		//设置数据为显示生产计划
		map.put("data", beyondExamMapper.showZProduce(paramMap));
		//设置总行数为显示生产计划总行数
		map.put("count", beyondExamMapper.showZProduceCount(paramMap));
		//设置消息
		map.put("msg", 0);
		//设置状态码
		map.put("code", 0);
		return map;
	}

	@Override
	public List<Map<String, Object>> findSenC(String designId) {
		// TODO Auto-generated method stub
		return beyondExamMapper.findSenC(designId);
	}

	@Override
	public List<Map<String, Object>> queryExamFdOld(String fdproId) {
		// TODO Auto-generated method stub
		return beyondExamMapper.queryExamFdOld(fdproId);
	}

}
